home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Systemmonitors / TaskY / Source / tasky.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  7.0 KB  |  376 lines
  1. /*
  2.  * TaskY
  3.  * 
  4.  * Simple replacement for TaskX. Why? Because I wanted to...
  5.  * 
  6.  * Martin W. Scott, 19 March 1993.
  7.  */
  8.  
  9. #include <exec/types.h>
  10. #include <exec/execbase.h>
  11. #include <exec/memory.h>
  12. #include <exec/tasks.h>
  13. #include <dos/dos.h>
  14. #include <dos/var.h>
  15. #include <libraries/gadtools.h>
  16. #include <intuition/intuition.h>
  17. #include <string.h>
  18. #include <proto/dos.h>
  19. #include <proto/exec.h>
  20. #include <proto/intuition.h>
  21. #include <proto/gadtools.h>
  22.  
  23. #include "sprintf.h"
  24.  
  25. static UBYTE VersTag[] = "\0$VER: TaskY 1.0";
  26.  
  27. #define ENVNAME        "TaskY_pos"
  28.  
  29. #include "ptask.h"
  30. PTASK *ptask;            /* current task node */
  31. WORD n=-1;            /* and its place in list */
  32. TASK *currtask;            /* and task, for relocation */
  33.  
  34. /* Local protos */
  35. void EasyEasyRequest(char *str);
  36. void CloseLibs(void);
  37. BOOL OpenLibs(void);
  38. void LoadPosition(void);
  39. void SavePosition(void);
  40. VOID __main(char *args);
  41. void HandleWindow(void);
  42.  
  43. /* Libraries */
  44. struct Library *GadToolsBase, *UtilityBase;
  45. struct GfxBase *GfxBase;
  46. struct IntuitionBase *IntuitionBase;
  47. extern struct ExecBase *SysBase;
  48.  
  49. #include "window.c"    /* gadtools-generated... */
  50.  
  51. /* dead simple requester */
  52. void
  53. EasyEasyRequest(char *str)
  54. {
  55.     struct EasyStruct es;
  56.  
  57.     es.es_StructSize = sizeof(struct EasyStruct);
  58.  
  59.     es.es_Flags = 0L;
  60.     es.es_Title = "TaskY Message";
  61.     es.es_TextFormat = str;
  62.     es.es_GadgetFormat = "OK";
  63.     EasyRequestArgs(NULL, &es, NULL, NULL);
  64. }
  65.  
  66. #define Msg(s) EasyEasyRequest(s)
  67.  
  68. void
  69. CloseLibs()
  70. {
  71.     if (GadToolsBase) CloseLibrary(GadToolsBase);
  72.     if (UtilityBase) CloseLibrary(UtilityBase);
  73.     if (GfxBase) CloseLibrary(GfxBase);
  74.     if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  75. }
  76.  
  77. BOOL
  78. OpenLibs()
  79. {
  80.     if ((IntuitionBase = (void *)OpenLibrary("intuition.library", 0L)) &&
  81.         (GfxBase = (void *)OpenLibrary("graphics.library", 37L)) &&
  82.         (UtilityBase = OpenLibrary("utility.library", 37L)) &&
  83.         (GadToolsBase = OpenLibrary("gadtools.library", 37L)))
  84.     {
  85.         return TRUE;
  86.     }
  87.     CloseLibs();
  88.     return FALSE;
  89. }
  90.  
  91. /* try to get position of window from env-var */
  92. void
  93. LoadPosition()
  94. {
  95.     UWORD pos[3];
  96.     LONG rc;
  97.  
  98.     rc = GetVar(ENVNAME, (UBYTE *)pos, 3*sizeof(UWORD), GVF_BINARY_VAR);
  99.     if (rc != -1)    /* okay */
  100.     {
  101.         TaskYLeft = pos[0];
  102.         TaskYTop = pos[1];
  103.     }
  104. }
  105.  
  106. /* save (as env-var) position of window */
  107. void
  108. SavePosition()
  109. {
  110.     UWORD pos[3];
  111.  
  112.     pos[0] = TaskYLeft;
  113.     pos[1] = TaskYTop;
  114.     pos[2] = 0;
  115.  
  116.     SetVar(ENVNAME, (UBYTE *)pos, 2*sizeof(UWORD)+1, GVF_GLOBAL_ONLY); 
  117.     /* don't care if it worked... */
  118. }
  119.  
  120. VOID
  121. __main(char *args)
  122. {
  123.     if (OpenLibs())
  124.     {
  125.         if (RefreshPTaskList())        /* read & copy list */
  126.         {
  127.             if (!SetupScreen())
  128.             {
  129.                 LoadPosition();
  130.                 if (!OpenTaskYWindow())
  131.                 {
  132.                     HandleWindow();
  133.                     CloseTaskYWindow();
  134.                 }
  135.                 else Msg("Couldn't open window");
  136.                 CloseDownScreen();
  137.                 SavePosition();
  138.             }
  139.             else Msg("Couldn't get screen data");
  140.  
  141.             DeletePTaskList();    /* and finally, delete list */
  142.         }
  143.         else Msg("Couldn't allocate memory");
  144.  
  145.         CloseLibs();
  146.     }
  147. }
  148.  
  149. /* get nth node in list - list MUST have >= n nodes!!! */
  150. struct Node *
  151. GetNode(struct List *lh, UWORD n)
  152. {
  153.     struct Node *ln;
  154.  
  155.     for (ln = lh->lh_Head; n--; ln = ln->ln_Succ)
  156.         ;
  157.     return ln;
  158. }
  159.  
  160. /* initialise individual gadget */
  161. void
  162. InitGadget(UWORD num, LONG tagtype, LONG tagvalue)
  163. {
  164.     GT_SetGadgetAttrs(TaskYGadgets[num], TaskYWnd, NULL, tagtype, tagvalue, TAG_DONE);
  165. }
  166.  
  167. /* initialise display */
  168. void
  169. InitGadgets(void)
  170. {
  171.     static char windtitle[25]; 
  172.  
  173.     InitGadget(GDX_ListView, GTLV_Labels, (LONG)&ptlist);
  174.     InitGadget(GDX_ListView, GTLV_Selected, n);
  175.     if (n >= 0)
  176.         InitGadget(GDX_Pri, GTIN_Number, ptask->pt_TaskPri);
  177.     else
  178.         InitGadget(GDX_Pri, GTIN_Number, 0);
  179.  
  180.     SPrintf(windtitle, "TaskY 1.0   %ld tasks", num_ptasks);
  181.     SetWindowTitles(TaskYWnd, windtitle, (UBYTE *)~0);
  182. }
  183.  
  184. /* update list and gadgets */
  185. void
  186. Update(void)
  187. {
  188.     PTASK *pt;
  189.     UWORD new_n;
  190.  
  191.     if (!RefreshPTaskList())
  192.         Msg("Couldn't allocate memory");
  193.  
  194.     if (n >= 0)    /* something was selected */
  195.     {
  196.         n = -1;
  197.         for (new_n = 0, pt = (PTASK *)ptlist.lh_Head;
  198.              pt->pt_Node.ln_Succ;
  199.              new_n++, pt = (PTASK *)pt->pt_Node.ln_Succ)
  200.         {
  201.             if (pt->pt_Task == currtask)
  202.             {
  203.                 n = new_n;
  204.                 ptask = pt;
  205.                 break;
  206.             }
  207.         }
  208.     }
  209.     InitGadgets();
  210. }
  211.  
  212. #define GadString(gadget)    ((struct StringInfo *)(gadget)->SpecialInfo)->Buffer
  213. #define GadNum(gadget)        ((struct StringInfo *)(gadget)->SpecialInfo)->LongInt
  214.  
  215. /* handle window gadgets/menus */
  216. void
  217. HandleWindow()
  218. {
  219.     struct IntuiMessage *msg;
  220.     struct Gadget *gad;
  221.     struct Task *task;
  222.     ULONG class;
  223.     UWORD code;
  224.     LONG sigs, sigmask, newpri;
  225.     BOOL zipped = FALSE;
  226.  
  227.     InitGadgets();
  228.  
  229.     sigmask = 1 << TaskYWnd->UserPort->mp_SigBit |
  230.           SIGBREAKF_CTRL_C;
  231.  
  232.     for (;;)    /* loop until return... */
  233.     {
  234.         sigs = Wait(sigmask);
  235.  
  236.         if (sigs & SIGBREAKF_CTRL_C)
  237.             return;
  238.  
  239.         while (msg = GT_GetIMsg(TaskYWnd->UserPort))
  240.         {
  241.             class = msg->Class;
  242.             code = msg->Code;
  243.             gad = (struct Gadget *)msg->IAddress;
  244.             GT_ReplyIMsg(msg);
  245.  
  246.             switch (class)
  247.             {
  248.             case CLOSEWINDOW:
  249.                 return;
  250.  
  251.             case REFRESHWINDOW:
  252.                 GT_BeginRefresh(TaskYWnd);
  253.                 GT_EndRefresh(TaskYWnd, TRUE);
  254.                 break;
  255.  
  256.             case CHANGEWINDOW:
  257.                 if (TaskYWnd->Width == TaskYWidth)
  258.                 {
  259.                     if (zipped)
  260.                     {
  261.                         /* unzipped! */
  262.                         zipped = FALSE;
  263.                         Update();
  264.                     }
  265.  
  266.                     /* not zipped, must be moved */
  267.                     TaskYLeft = TaskYWnd->LeftEdge;
  268.                     TaskYTop = TaskYWnd->TopEdge;
  269.                 }
  270.                 else if (TaskYWnd->Width < TaskYWidth)
  271.                     zipped = TRUE;
  272.                 break;
  273.  
  274.             case VANILLAKEY:
  275.                 switch (code)
  276.                 {
  277.                 case 'u': case 'U':
  278.                     Update();
  279.                     break;
  280.                 case 'z': case 'Z':
  281.                     ZipWindow(TaskYWnd);
  282.                     break;
  283.                 case 27:  /* ESCAPE */
  284.                     return;
  285.                 }
  286.                 break;
  287.  
  288.             case GADGETDOWN:
  289.             case GADGETUP:
  290.                 if (gad->GadgetID == GD_ListView)
  291.                 {
  292.                     n = code;
  293.                     ptask = (PTASK *)GetNode(&ptlist, n);
  294.                     currtask = ptask->pt_Task;
  295.                     InitGadget(GDX_Pri, GTIN_Number, ptask->pt_TaskPri);
  296.                     ActivateGadget(TaskYGadgets[GD_Pri], TaskYWnd, NULL);
  297.                     break;
  298.                 }
  299.                 else if (gad->GadgetID == GD_Update)
  300.                 {
  301.                     Update();
  302.                     break;
  303.                 }
  304.                 else /* some other button */
  305.                 {
  306.                     if (n < 0)
  307.                         break;
  308.                     /* okay, do the changes */
  309.                     Forbid();
  310.                     if (!(task = GetOrigTask(ptask)))
  311.                     {
  312.                         Permit();
  313.                         break;
  314.                     }
  315.  
  316.                     switch (gad->GadgetID)
  317.                     {
  318.                     case GD_MinusFive:
  319.                         SetTaskPri(task, -5);
  320.                         break;
  321.  
  322.                     case GD_MinusOne:
  323.                         SetTaskPri(task, -1);
  324.                         break;
  325.  
  326.                     case GD_Zero:
  327.                         SetTaskPri(task, 0);
  328.                         break;
  329.  
  330.                     case GD_PlusOne:
  331.                         SetTaskPri(task, 1);
  332.                         break;
  333.  
  334.                     case GD_PlusFive:
  335.                         SetTaskPri(task, 5);
  336.                         break;
  337.  
  338.                     case GD_Pri:
  339.                         newpri = GadNum(gad);
  340.                         if (newpri >= -128 && newpri < 128)
  341.                             SetTaskPri(task, newpri);
  342.                         break;
  343.  
  344.                     case GD_SigC:
  345.                         Signal(task, SIGBREAKF_CTRL_C);
  346.                         /* give it a chance to work */
  347.                         if (task != SysBase->ThisTask)
  348.                             Delay(50);
  349.                         break;
  350.  
  351.                     case GD_SigD:
  352.                         Signal(task, SIGBREAKF_CTRL_D);
  353.                         break;
  354.  
  355.                     case GD_SigE:
  356.                         Signal(task, SIGBREAKF_CTRL_E);
  357.                         break;
  358.  
  359.                     case GD_SigF:
  360.                         Signal(task, SIGBREAKF_CTRL_F);
  361.                         break;
  362.  
  363.                     } /* switch (gadget id) */
  364.                     Permit();
  365.                     Update();
  366.                     break;
  367.                 }
  368.  
  369.             } /* switch (class) */
  370.  
  371.         } /* while */
  372.  
  373.     } /* for */
  374.  
  375. } /* HandleWindow() */
  376.